package demo3;

import java.util.*;

public class TestDemo {
    //put方法是添加元素
    //remove方法根据键删除键值对元素
    //clear移除所有键值对元素
    //containsKey  是否包含指定的键
    //containsValue  是否包含指定的值
    //isEmpty判断集合是否为空
    //size 集合的长度 键值对的个数
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("a",5);
        map.put("b",6);
        map.put("c",7);
        map.put("d",8);
        map.put("e",9);
        //map遍历方式
        //将键集合
        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
        for(Map.Entry<String,Integer> me: entrySet){
             String key = me.getKey();
             Integer value = me.getValue();
            System.out.println("key->"+key+"value->"+value);
        }

//       Set<String> keySet = map.keySet();
//       for(String key:keySet){
//           Integer e = map.get(key);
//           System.out.print(e+" ");
//       }

//        //获取所有键的集合
//        Set<String> keySet = map.keySet();
//        for(String s:keySet){
//            //获取键的结合
//            System.out.print(s+" ");
//        }
//        System.out.println();
//        System.out.println("+++++++++++");
//        //获取所有值的结合
//        Collection<Integer> values = map.values();
//        for(Integer e:values){
//            //获取键的结合
//            System.out.print(e+" ");
//        }

//        System.out.println(map);
//        System.out.println("===============");
//       // map.remove("a");
//       // System.out.println(map.get("e"));
//        System.out.println(map.getOrDefault("p",100));
//       // System.out.println(map);
    }

    //map<K,V>  K,V 模型 K代表键  V代表值
    //将键映射到值的对象，不包含重复的键，每个键最多映射一个值
    public static void main7(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("2021060532","石方旭");
        map.put("2021060531","liming");
        map.put("2021060533","wwfhaj");
        map.put("2021060534","dingyuwei");
        map.put("2021060532","石方旭lll");
        //当有相同的键值时，后面的会将前面的进行覆盖
        System.out.println(map);
    }

    //产生随机数案例
    public static void main6(String[] args) {
        Set<Integer> set  =new TreeSet<>();
        Random r = new Random();
        while(set.size()<10){
            int num = r.nextInt(20)+1;
            set.add(num);
        }
        System.out.println(set);
    }

    //使用TreeSet集合可以在对象里面实现comparable接口也可以穿一个comparator比较器进行比较
    public static void main5(String[] args) {
        //通过比较器来进行排序
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num = o1.getAge()-o2.getAge();
                int num2 = num==0?o1.getName().compareTo(o2.getName()):num;
                return num2;
            }
        });
        Student s1 = new Student("石方旭",19);
        Student s2 = new Student("丁玉伟",20);
        Student s3 = new Student("柴晨浩",18);
        Student s4 = new Student("娄可森",16);
        Student s5 = new Student("里方旭",19);
        Student s6 = new Student("石方旭",19);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        for(Student s:ts){
            System.out.println("姓名："+s.getName()+"年龄："+s.getAge());
        }
    }

    //自然排序comparable进行排序
    //TreeSet的无参构造是自然排序的，需要实现comparable接口，重写compareTo方法
    //不能只用主要条件进行比较应该采用主要条件和次要条件相结合一起进行比较
    public static void main4(String[] args) {
        TreeSet<Student> ts = new TreeSet<Student>();
        Student s1 = new Student("石方旭",19);
        Student s2 = new Student("丁玉伟",20);
        Student s3 = new Student("柴晨浩",18);
        Student s4 = new Student("娄可森",16);
        Student s5 = new Student("里方旭",19);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        for(Student s:ts){
            System.out.println("姓名："+s.getName()+"年龄："+s.getAge());
        }
    }

    //TreeSet集合是有序的，按照一定的规则来进行排序的，排序方式取决于构造方法
    //无参的构造方法是按照字典序
    //有参的构造方法是按照比较器来进行排序的
    //由于间接实现set接口，元素是不重复的

    public static void main3(String[] args) {
         TreeSet<Integer> treeSet = new TreeSet<>();
         treeSet.add(10);
         treeSet.add(40);
         treeSet.add(50);
         treeSet.add(20);
         treeSet.add(30);
         for(Integer s:treeSet){
             System.out.println(s);
        }
    }


    //linkedHashSet是由链表和哈希表实现的set接口，具有可预测的迭代顺序
    //由链表保证有序，也就是说元素的取出顺序和存储顺序是一致的
    //由哈希表保证元素的唯一性，也就是说没有重复的元素
    public static void main2(String[] args) {
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("hello");
        linkedHashSet.add("world");
        linkedHashSet.add("java");
        linkedHashSet.add("hello");
        for(String s:linkedHashSet){
            System.out.println(s);
        }
    }

    public static void main1(String[] args) {
        //创建hashset对象
        HashSet<Student> hashSet = new HashSet<Student>();
        Student student1 = new Student("黎明",15);
        Student student2 = new Student("往明",1);
        Student student3 = new Student("破明",125);
        Student student4 = new Student("了明",16);
        Student student5 = new Student("黎明",15);

        hashSet.add(student1);
        hashSet.add(student2);
        hashSet.add(student3);
        hashSet.add(student4);
        hashSet.add(student5);
        for(Student s:hashSet){
            System.out.println("姓名："+s.getName()+"年龄："+s.getAge());
        }

    }
}
